/*! 
 * jQuery Steps v1.1.0 - 09/04/2014
 * Copyright (c) 2014 Rafael Staib (http://www.jquery-steps.com)
 * Licensed under MIT http://www.opensource.org/licenses/MIT
 */
;(function ($, undefined) {
    $.fn.extend({
        _aria: function (name, value) {
            return this.attr("aria-" + name, value);
        },

        _removeAria: function (name) {
            return this.removeAttr("aria-" + name);
        },

        _enableAria: function (enable) {
            return (enable == null || enable) ?
                this.removeClass("disabled")._aria("disabled", "false") :
                this.addClass("disabled")._aria("disabled", "true");
        },

        _showAria: function (show) {
            return (show == null || show) ?
                this.show()._aria("hidden", "false") :
                this.hide()._aria("hidden", "true");
        },

        _selectAria: function (select) {
            return (select == null || select) ?
                this.addClass("current")._aria("selected", "true") :
                this.removeClass("current")._aria("selected", "false");
        },

        _id: function (id) {
            return (id) ? this.attr("id", id) : this.attr("id");
        }
    });

    if (!String.prototype.format) {
        String.prototype.format = function () {
            var args = (arguments.length === 1 && $.isArray(arguments[0])) ? arguments[0] : arguments;
            var formattedString = this;
            for (var i = 0; i < args.length; i++) {
                var pattern = new RegExp("\\{" + i + "\\}", "gm");
                formattedString = formattedString.replace(pattern, args[i]);
            }
            return formattedString;
        };
    }

    /**
     * A global unique id count.
     *
     * @static
     * @private
     * @property _uniqueId
     * @type Integer
     **/
    var _uniqueId = 0;

    /**
     * The plugin prefix for cookies.
     *
     * @final
     * @private
     * @property _cookiePrefix
     * @type String
     **/
    var _cookiePrefix = "jQu3ry_5teps_St@te_";

    /**
     * Suffix for the unique tab id.
     *
     * @final
     * @private
     * @property _tabSuffix
     * @type String
     * @since 0.9.7
     **/
    var _tabSuffix = "-t-";

    /**
     * Suffix for the unique tabpanel id.
     *
     * @final
     * @private
     * @property _tabpanelSuffix
     * @type String
     * @since 0.9.7
     **/
    var _tabpanelSuffix = "-p-";

    /**
     * Suffix for the unique title id.
     *
     * @final
     * @private
     * @property _titleSuffix
     * @type String
     * @since 0.9.7
     **/
    var _titleSuffix = "-h-";

    /**
     * An error message for an "index out of range" error.
     *
     * @final
     * @private
     * @property _indexOutOfRangeErrorMessage
     * @type String
     **/
    var _indexOutOfRangeErrorMessage = "Index out of range.";

    /**
     * An error message for an "missing corresponding element" error.
     *
     * @final
     * @private
     * @property _missingCorrespondingElementErrorMessage
     * @type String
     **/
    var _missingCorrespondingElementErrorMessage = "One or more corresponding step {0} are missing.";

    /**
     * Adds a step to the cache.
     *
     * @static
     * @private
     * @method addStepToCache
     * @param wizard {Object} A jQuery wizard object
     * @param step {Object} The step object to add
     **/
    function addStepToCache(wizard, step) {
        getSteps(wizard).push(step);
    }

    function analyzeData(wizard, options, state) {
        var stepTitles = wizard.children(options.headerTag),
            stepContents = wizard.children(options.bodyTag);

        // Validate content
        if (stepTitles.length > stepContents.length) {
            throwError(_missingCorrespondingElementErrorMessage, "contents");
        }
        else if (stepTitles.length < stepContents.length) {
            throwError(_missingCorrespondingElementErrorMessage, "titles");
        }

        var startIndex = options.startIndex;

        state.stepCount = stepTitles.length;

        // Tries to load the saved state (step position)
        if (options.saveState && $.cookie) {
            var savedState = $.cookie(_cookiePrefix + getUniqueId(wizard));
            // Sets the saved position to the start index if not undefined or out of range
            var savedIndex = parseInt(savedState, 0);
            if (!isNaN(savedIndex) && savedIndex < state.stepCount) {
                startIndex = savedIndex;
            }
        }

        state.currentIndex = startIndex;

        stepTitles.each(function (index) {
            var item = $(this), // item == header
                content = stepContents.eq(index),
                modeData = content.data("mode"),
                mode = (modeData == null) ? contentMode.html : getValidEnumValue(contentMode,
                    (/^\s*$/.test(modeData) || isNaN(modeData)) ? modeData : parseInt(modeData, 0)),
                contentUrl = (mode === contentMode.html || content.data("url") === undefined) ?
                    "" : content.data("url"),
                contentLoaded = (mode !== contentMode.html && content.data("loaded") === "1"),
                step = $.extend({}, stepModel, {
                    title: item.html(),
                    content: (mode === contentMode.html) ? content.html() : "",
                    contentUrl: contentUrl,
                    contentMode: mode,
                    contentLoaded: contentLoaded
                });

            addStepToCache(wizard, step);
        });
    }

    /**
     * Triggers the onCanceled event.
     *
     * @static
     * @private
     * @method cancel
     * @param wizard {Object} The jQuery wizard object
     **/
    function cancel(wizard) {
        wizard.triggerHandler("canceled");
    }

    function decreaseCurrentIndexBy(state, decreaseBy) {
        return state.currentIndex - decreaseBy;
    }

    /**
     * Removes the control functionality completely and transforms the current state to the initial HTML structure.
     *
     * @static
     * @private
     * @method destroy
     * @param wizard {Object} A jQuery wizard object
     **/
    function destroy(wizard, options) {
        var eventNamespace = getEventNamespace(wizard);

        // Remove virtual data objects from the wizard
        wizard.unbind(eventNamespace).removeData("uid").removeData("options")
            .removeData("state").removeData("steps").removeData("eventNamespace")
            .find(".actions a").unbind(eventNamespace);

        // Remove attributes and CSS classes from the wizard
        wizard.removeClass(options.clearFixCssClass + " vertical");

        var contents = wizard.find(".content > *");

        // Remove virtual data objects from panels and their titles
        contents.removeData("loaded").removeData("mode").removeData("url");

        // Remove attributes, CSS classes and reset inline styles on all panels and their titles
        contents.removeAttr("id").removeAttr("role").removeAttr("tabindex")
            .removeAttr("class").removeAttr("style")._removeAria("labelledby")
            ._removeAria("hidden");

        // Empty panels if the mode is set to 'async' or 'iframe'
        wizard.find(".content > [data-mode='async'],.content > [data-mode='iframe']").empty();

        var wizardSubstitute = $("<{0} class=\"{1}\"></{0}>".format(wizard.get(0).tagName, wizard.attr("class")));

        var wizardId = wizard._id();
        if (wizardId != null && wizardId !== "") {
            wizardSubstitute._id(wizardId);
        }

        wizardSubstitute.html(wizard.find(".content").html());
        wizard.after(wizardSubstitute);
        wizard.remove();

        return wizardSubstitute;
    }

    /**
     * Triggers the onFinishing and onFinished event.
     *
     * @static
     * @private
     * @method finishStep
     * @param wizard {Object} The jQuery wizard object
     * @param state {Object} The state container of the current wizard
     **/
    function finishStep(wizard, state) {
        var currentStep = wizard.find(".steps li").eq(state.currentIndex);

        if (wizard.triggerHandler("finishing", [state.currentIndex])) {
            currentStep.addClass("done").removeClass("error");
            wizard.triggerHandler("finished", [state.currentIndex]);
        }
        else {
            currentStep.addClass("error");
        }
    }

    /**
     * Gets or creates if not exist an unique event namespace for the given wizard instance.
     *
     * @static
     * @private
     * @method getEventNamespace
     * @param wizard {Object} A jQuery wizard object
     * @return {String} Returns the unique event namespace for the given wizard
     */
    function getEventNamespace(wizard) {
        var eventNamespace = wizard.data("eventNamespace");

        if (eventNamespace == null) {
            eventNamespace = "." + getUniqueId(wizard);
            wizard.data("eventNamespace", eventNamespace);
        }

        return eventNamespace;
    }

    function getStepAnchor(wizard, index) {
        var uniqueId = getUniqueId(wizard);

        return wizard.find("#" + uniqueId + _tabSuffix + index);
    }

    function getStepPanel(wizard, index) {
        var uniqueId = getUniqueId(wizard);

        return wizard.find("#" + uniqueId + _tabpanelSuffix + index);
    }

    function getStepTitle(wizard, index) {
        var uniqueId = getUniqueId(wizard);

        return wizard.find("#" + uniqueId + _titleSuffix + index);
    }

    function getOptions(wizard) {
        return wizard.data("options");
    }

    function getState(wizard) {
        return wizard.data("state");
    }

    function getSteps(wizard) {
        return wizard.data("steps");
    }

    /**
     * Gets a specific step object by index.
     *
     * @static
     * @private
     * @method getStep
     * @param index {Integer} An integer that belongs to the position of a step
     * @return {Object} A specific step object
     **/
    function getStep(wizard, index) {
        var steps = getSteps(wizard);

        if (index < 0 || index >= steps.length) {
            throwError(_indexOutOfRangeErrorMessage);
        }

        return steps[index];
    }

    /**
     * Gets or creates if not exist an unique id from the given wizard instance.
     *
     * @static
     * @private
     * @method getUniqueId
     * @param wizard {Object} A jQuery wizard object
     * @return {String} Returns the unique id for the given wizard
     */
    function getUniqueId(wizard) {
        var uniqueId = wizard.data("uid");

        if (uniqueId == null) {
            uniqueId = wizard._id();
            if (uniqueId == null) {
                uniqueId = "steps-uid-".concat(_uniqueId);
                wizard._id(uniqueId);
            }

            _uniqueId++;
            wizard.data("uid", uniqueId);
        }

        return uniqueId;
    }

    /**
     * Gets a valid enum value by checking a specific enum key or value.
     *
     * @static
     * @private
     * @method getValidEnumValue
     * @param enumType {Object} Type of enum
     * @param keyOrValue {Object} Key as `String` or value as `Integer` to check for
     */
    function getValidEnumValue(enumType, keyOrValue) {
        validateArgument("enumType", enumType);
        validateArgument("keyOrValue", keyOrValue);

        // Is key
        if (typeof keyOrValue === "string") {
            var value = enumType[keyOrValue];
            if (value === undefined) {
                throwError("The enum key '{0}' does not exist.", keyOrValue);
            }

            return value;
        }
        // Is value
        else if (typeof keyOrValue === "number") {
            for (var key in enumType) {
                if (enumType[key] === keyOrValue) {
                    return keyOrValue;
                }
            }

            throwError("Invalid enum value '{0}'.", keyOrValue);
        }
        // Type is not supported
        else {
            throwError("Invalid key or value type.");
        }
    }

    /**
     * Routes to the next step.
     *
     * @static
     * @private
     * @method goToNextStep
     * @param wizard {Object} The jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @return {Boolean} Indicates whether the action executed
     **/
    function goToNextStep(wizard, options, state) {
        return paginationClick(wizard, options, state, increaseCurrentIndexBy(state, 1));
    }

    /**
     * Routes to the previous step.
     *
     * @static
     * @private
     * @method goToPreviousStep
     * @param wizard {Object} The jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @return {Boolean} Indicates whether the action executed
     **/
    function goToPreviousStep(wizard, options, state) {
        return paginationClick(wizard, options, state, decreaseCurrentIndexBy(state, 1));
    }

    /**
     * Routes to a specific step by a given index.
     *
     * @static
     * @private
     * @method goToStep
     * @param wizard {Object} The jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @param index {Integer} The position (zero-based) to route to
     * @return {Boolean} Indicates whether the action succeeded or failed
     **/
    function goToStep(wizard, options, state, index) {
        if (index < 0 || index >= state.stepCount) {
            throwError(_indexOutOfRangeErrorMessage);
        }

        if (options.forceMoveForward && index < state.currentIndex) {
            return;
        }

        var oldIndex = state.currentIndex;
        if (wizard.triggerHandler("stepChanging", [state.currentIndex, index])) {
            // Save new state
            state.currentIndex = index;
            saveCurrentStateToCookie(wizard, options, state);

            // Change visualisation
            refreshStepNavigation(wizard, options, state, oldIndex);
            refreshPagination(wizard, options, state);
            loadAsyncContent(wizard, options, state);
            startTransitionEffect(wizard, options, state, index, oldIndex, function () {
                wizard.triggerHandler("stepChanged", [index, oldIndex]);
            });
        }
        else {
            wizard.find(".steps li").eq(oldIndex).addClass("error");
        }

        return true;
    }

    function increaseCurrentIndexBy(state, increaseBy) {
        return state.currentIndex + increaseBy;
    }

    /**
     * Initializes the component.
     *
     * @static
     * @private
     * @method initialize
     * @param options {Object} The component settings
     **/
    function initialize(options) {
        /*jshint -W040 */
        var opts = $.extend(true, {}, defaults, options);

        return this.each(function () {
            var wizard = $(this);
            var state = {
                currentIndex: opts.startIndex,
                currentStep: null,
                stepCount: 0,
                transitionElement: null
            };

            // Create data container
            wizard.data("options", opts);
            wizard.data("state", state);
            wizard.data("steps", []);

            analyzeData(wizard, opts, state);
            render(wizard, opts, state);
            registerEvents(wizard, opts);

            // Trigger focus
            if (opts.autoFocus && _uniqueId === 0) {
                getStepAnchor(wizard, opts.startIndex).focus();
            }

            wizard.triggerHandler("init", [opts.startIndex]);
        });
    }

    /**
     * Inserts a new step to a specific position.
     *
     * @static
     * @private
     * @method insertStep
     * @param wizard {Object} The jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @param index {Integer} The position (zero-based) to add
     * @param step {Object} The step object to add
     * @example
     *     $("#wizard").steps().insert(0, {
 *         title: "Title",
 *         content: "", // optional
 *         contentMode: "async", // optional
 *         contentUrl: "/Content/Step/1" // optional
 *     });
     * @chainable
     **/
    function insertStep(wizard, options, state, index, step) {
        if (index < 0 || index > state.stepCount) {
            throwError(_indexOutOfRangeErrorMessage);
        }

        // TODO: Validate step object

        // Change data
        step = $.extend({}, stepModel, step);
        insertStepToCache(wizard, index, step);
        if (state.currentIndex !== state.stepCount && state.currentIndex >= index) {
            state.currentIndex++;
            saveCurrentStateToCookie(wizard, options, state);
        }
        state.stepCount++;

        var contentContainer = wizard.find(".content"),
            header = $("<{0}>{1}</{0}>".format(options.headerTag, step.title)),
            body = $("<{0}></{0}>".format(options.bodyTag));

        if (step.contentMode == null || step.contentMode === contentMode.html) {
            body.html(step.content);
        }

        if (index === 0) {
            contentContainer.prepend(body).prepend(header);
        }
        else {
            getStepPanel(wizard, (index - 1)).after(body).after(header);
        }

        renderBody(wizard, state, body, index);
        renderTitle(wizard, options, state, header, index);
        refreshSteps(wizard, options, state, index);
        if (index === state.currentIndex) {
            refreshStepNavigation(wizard, options, state);
        }
        refreshPagination(wizard, options, state);

        return wizard;
    }

    /**
     * Inserts a step object to the cache at a specific position.
     *
     * @static
     * @private
     * @method insertStepToCache
     * @param wizard {Object} A jQuery wizard object
     * @param index {Integer} The position (zero-based) to add
     * @param step {Object} The step object to add
     **/
    function insertStepToCache(wizard, index, step) {
        getSteps(wizard).splice(index, 0, step);
    }

    /**
     * Handles the keyup DOM event for pagination.
     *
     * @static
     * @private
     * @event keyup
     * @param event {Object} An event object
     */
    function keyUpHandler(event) {
        var wizard = $(this),
            options = getOptions(wizard),
            state = getState(wizard);

        if (options.suppressPaginationOnFocus && wizard.find(":focus").is(":input")) {
            event.preventDefault();
            return false;
        }

        var keyCodes = {left: 37, right: 39};
        if (event.keyCode === keyCodes.left) {
            event.preventDefault();
            goToPreviousStep(wizard, options, state);
        }
        else if (event.keyCode === keyCodes.right) {
            event.preventDefault();
            goToNextStep(wizard, options, state);
        }
    }

    /**
     * Loads and includes async content.
     *
     * @static
     * @private
     * @method loadAsyncContent
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     */
    function loadAsyncContent(wizard, options, state) {
        if (state.stepCount > 0) {
            var currentIndex = state.currentIndex,
                currentStep = getStep(wizard, currentIndex);

            if (!options.enableContentCache || !currentStep.contentLoaded) {
                switch (getValidEnumValue(contentMode, currentStep.contentMode)) {
                    case contentMode.iframe:
                        wizard.find(".content > .body").eq(state.currentIndex).empty()
                            .html("<iframe src=\"" + currentStep.contentUrl + "\" frameborder=\"0\" scrolling=\"auto\" />")
                            .data("loaded", "1");
                        break;

                    case contentMode.async:
                        var currentStepContent = getStepPanel(wizard, currentIndex)._aria("busy", "true")
                            .empty().append(renderTemplate(options.loadingTemplate, {text: options.labels.loading}));

                        $.ajax({url: currentStep.contentUrl, cache: false}).done(function (data) {
                            currentStepContent.empty().html(data)._aria("busy", "false").data("loaded", "1");
                            wizard.triggerHandler("contentLoaded", [currentIndex]);
                        });
                        break;
                }
            }
        }
    }

    /**
     * Fires the action next or previous click event.
     *
     * @static
     * @private
     * @method paginationClick
     * @param wizard {Object} The jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @param index {Integer} The position (zero-based) to route to
     * @return {Boolean} Indicates whether the event fired successfully or not
     **/
    function paginationClick(wizard, options, state, index) {
        var oldIndex = state.currentIndex;

        if (index >= 0 && index < state.stepCount && !(options.forceMoveForward && index < state.currentIndex)) {
            var anchor = getStepAnchor(wizard, index),
                parent = anchor.parent(),
                isDisabled = parent.hasClass("disabled");

            // Enable the step to make the anchor clickable!
            parent._enableAria();
            anchor.click();

            // An error occured
            if (oldIndex === state.currentIndex && isDisabled) {
                // Disable the step again if current index has not changed; prevents click action.
                parent._enableAria(false);
                return false;
            }

            return true;
        }

        return false;
    }

    /**
     * Fires when a pagination click happens.
     *
     * @static
     * @private
     * @event click
     * @param event {Object} An event object
     */
    function paginationClickHandler(event) {
        event.preventDefault();

        var anchor = $(this),
            wizard = anchor.parent().parent().parent().parent(),
            options = getOptions(wizard),
            state = getState(wizard),
            href = anchor.attr("href");

        switch (href.substring(href.lastIndexOf("#") + 1)) {
            case "cancel":
                cancel(wizard);
                break;

            case "finish":
                finishStep(wizard, state);
                break;

            case "next":
                goToNextStep(wizard, options, state);
                break;

            case "previous":
                goToPreviousStep(wizard, options, state);
                break;
        }
    }

    /**
     * Refreshs the visualization state for the entire pagination.
     *
     * @static
     * @private
     * @method refreshPagination
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     */
    function refreshPagination(wizard, options, state) {
        if (options.enablePagination) {
            var finish = wizard.find(".actions a[href$='#finish']").parent(),
                next = wizard.find(".actions a[href$='#next']").parent();

            if (!options.forceMoveForward) {
                var previous = wizard.find(".actions a[href$='#previous']").parent();
                previous._enableAria(state.currentIndex > 0);
            }

            if (options.enableFinishButton && options.showFinishButtonAlways) {
                finish._enableAria(state.stepCount > 0);
                next._enableAria(state.stepCount > 1 && state.stepCount > (state.currentIndex + 1));
            }
            else {
                finish._showAria(options.enableFinishButton && state.stepCount === (state.currentIndex + 1));
                next._showAria(state.stepCount === 0 || state.stepCount > (state.currentIndex + 1))._enableAria(state.stepCount > (state.currentIndex + 1) || !options.enableFinishButton);
            }
        }
    }

    /**
     * Refreshs the visualization state for the step navigation (tabs).
     *
     * @static
     * @private
     * @method refreshStepNavigation
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @param [oldIndex] {Integer} The index of the prior step
     */
    function refreshStepNavigation(wizard, options, state, oldIndex) {
        var currentOrNewStepAnchor = getStepAnchor(wizard, state.currentIndex),
            currentInfo = $("<span class=\"current-info audible\">" + options.labels.current + " </span>"),
            stepTitles = wizard.find(".content > .title");

        if (oldIndex != null) {
            var oldStepAnchor = getStepAnchor(wizard, oldIndex);
            oldStepAnchor.parent().addClass("done").removeClass("error")._selectAria(false);
            stepTitles.eq(oldIndex).removeClass("current").next(".body").removeClass("current");
            currentInfo = oldStepAnchor.find(".current-info");
            currentOrNewStepAnchor.focus();
        }

        currentOrNewStepAnchor.prepend(currentInfo).parent()._selectAria().removeClass("done")._enableAria();
        stepTitles.eq(state.currentIndex).addClass("current").next(".body").addClass("current");
    }

    /**
     * Refreshes step buttons and their related titles beyond a certain position.
     *
     * @static
     * @private
     * @method refreshSteps
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @param index {Integer} The start point for refreshing ids
     */
    function refreshSteps(wizard, options, state, index) {
        var uniqueId = getUniqueId(wizard);

        for (var i = index; i < state.stepCount; i++) {
            var uniqueStepId = uniqueId + _tabSuffix + i,
                uniqueBodyId = uniqueId + _tabpanelSuffix + i,
                uniqueHeaderId = uniqueId + _titleSuffix + i,
                title = wizard.find(".title").eq(i)._id(uniqueHeaderId);

            wizard.find(".steps a").eq(i)._id(uniqueStepId)
                ._aria("controls", uniqueBodyId).attr("href", "#" + uniqueHeaderId)
                .html(renderTemplate(options.titleTemplate, {index: i + 1, title: title.html()}));
            wizard.find(".body").eq(i)._id(uniqueBodyId)
                ._aria("labelledby", uniqueHeaderId);
        }
    }

    function registerEvents(wizard, options) {
        var eventNamespace = getEventNamespace(wizard);

        wizard.bind("canceled" + eventNamespace, options.onCanceled);
        wizard.bind("contentLoaded" + eventNamespace, options.onContentLoaded);
        wizard.bind("finishing" + eventNamespace, options.onFinishing);
        wizard.bind("finished" + eventNamespace, options.onFinished);
        wizard.bind("init" + eventNamespace, options.onInit);
        wizard.bind("stepChanging" + eventNamespace, options.onStepChanging);
        wizard.bind("stepChanged" + eventNamespace, options.onStepChanged);

        if (options.enableKeyNavigation) {
            wizard.bind("keyup" + eventNamespace, keyUpHandler);
        }

        wizard.find(".actions a").bind("click" + eventNamespace, paginationClickHandler);
    }

    /**
     * Removes a specific step by an given index.
     *
     * @static
     * @private
     * @method removeStep
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @param index {Integer} The position (zero-based) of the step to remove
     * @return Indecates whether the item is removed.
     **/
    function removeStep(wizard, options, state, index) {
        // Index out of range and try deleting current item will return false.
        if (index < 0 || index >= state.stepCount || state.currentIndex === index) {
            return false;
        }

        // Change data
        removeStepFromCache(wizard, index);
        if (state.currentIndex > index) {
            state.currentIndex--;
            saveCurrentStateToCookie(wizard, options, state);
        }
        state.stepCount--;

        getStepTitle(wizard, index).remove();
        getStepPanel(wizard, index).remove();
        getStepAnchor(wizard, index).parent().remove();

        // Set the "first" class to the new first step button
        if (index === 0) {
            wizard.find(".steps li").first().addClass("first");
        }

        // Set the "last" class to the new last step button
        if (index === state.stepCount) {
            wizard.find(".steps li").eq(index).addClass("last");
        }

        refreshSteps(wizard, options, state, index);
        refreshPagination(wizard, options, state);

        return true;
    }

    function removeStepFromCache(wizard, index) {
        getSteps(wizard).splice(index, 1);
    }

    /**
     * Transforms the base html structure to a more sensible html structure.
     *
     * @static
     * @private
     * @method render
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     **/
    function render(wizard, options, state) {
        // Create a content wrapper and copy HTML from the intial wizard structure
        var wrapperTemplate = "<{0} class=\"{1}\">{2}</{0}>",
            orientation = getValidEnumValue(stepsOrientation, options.stepsOrientation),
            verticalCssClass = (orientation === stepsOrientation.vertical) ? " vertical" : "",
            contentWrapper = $(wrapperTemplate.format(options.contentContainerTag, "content " + options.clearFixCssClass, wizard.html())),
            stepsWrapper = $(wrapperTemplate.format(options.stepsContainerTag, "steps " + options.clearFixCssClass, "<ul role=\"tablist\"></ul>")),
            stepTitles = contentWrapper.children(options.headerTag),
            stepContents = contentWrapper.children(options.bodyTag);

        // Transform the wizard wrapper and remove the inner HTML
        wizard.attr("role", "application").empty().append(stepsWrapper).append(contentWrapper)
            .addClass(options.cssClass + " " + options.clearFixCssClass + verticalCssClass);

        // Add WIA-ARIA support
        stepContents.each(function (index) {
            renderBody(wizard, state, $(this), index);
        });

        stepTitles.each(function (index) {
            renderTitle(wizard, options, state, $(this), index);
        });

        refreshStepNavigation(wizard, options, state);
        renderPagination(wizard, options, state);
    }

    /**
     * Transforms the body to a proper tabpanel.
     *
     * @static
     * @private
     * @method renderBody
     * @param wizard {Object} A jQuery wizard object
     * @param body {Object} A jQuery body object
     * @param index {Integer} The position of the body
     */
    function renderBody(wizard, state, body, index) {
        var uniqueId = getUniqueId(wizard),
            uniqueBodyId = uniqueId + _tabpanelSuffix + index,
            uniqueHeaderId = uniqueId + _titleSuffix + index;

        body._id(uniqueBodyId).attr("role", "tabpanel")._aria("labelledby", uniqueHeaderId)
            .addClass("body")._showAria(state.currentIndex === index);
    }

    /**
     * Renders a pagination if enabled.
     *
     * @static
     * @private
     * @method renderPagination
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     */
    function renderPagination(wizard, options, state) {
        if (options.enablePagination) {
            var pagination = "<{0} class=\"actions {1}\"><ul role=\"menu\" aria-label=\"{2}\">{3}</ul></{0}>",
                buttonTemplate = "<li><a href=\"#{0}\" role=\"menuitem\">{1}</a></li>",
                buttons = "";

            if (!options.forceMoveForward) {
                buttons += buttonTemplate.format("previous", options.labels.previous);
            }

            buttons += buttonTemplate.format("next", options.labels.next);

            if (options.enableFinishButton) {
                buttons += buttonTemplate.format("finish", options.labels.finish);
            }

            if (options.enableCancelButton) {
                buttons += buttonTemplate.format("cancel", options.labels.cancel);
            }

            wizard.append(pagination.format(options.actionContainerTag, options.clearFixCssClass,
                options.labels.pagination, buttons));

            refreshPagination(wizard, options, state);
            loadAsyncContent(wizard, options, state);
        }
    }

    /**
     * Renders a template and replaces all placeholder.
     *
     * @static
     * @private
     * @method renderTemplate
     * @param template {String} A template
     * @param substitutes {Object} A list of substitute
     * @return {String} The rendered template
     */
    function renderTemplate(template, substitutes) {
        var matches = template.match(/#([a-z]*)#/gi);

        for (var i = 0; i < matches.length; i++) {
            var match = matches[i],
                key = match.substring(1, match.length - 1);

            if (substitutes[key] === undefined) {
                throwError("The key '{0}' does not exist in the substitute collection!", key);
            }

            template = template.replace(match, substitutes[key]);
        }

        return template;
    }

    /**
     * Transforms the title to a step item button.
     *
     * @static
     * @private
     * @method renderTitle
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     * @param header {Object} A jQuery header object
     * @param index {Integer} The position of the header
     */
    function renderTitle(wizard, options, state, header, index) {
        var uniqueId = getUniqueId(wizard),
            uniqueStepId = uniqueId + _tabSuffix + index,
            uniqueBodyId = uniqueId + _tabpanelSuffix + index,
            uniqueHeaderId = uniqueId + _titleSuffix + index,
            stepCollection = wizard.find(".steps > ul"),
            title = renderTemplate(options.titleTemplate, {
                index: index + 1,
                title: header.html()
            }),
            stepItem = $("<li role=\"tab\"><a id=\"" + uniqueStepId + "\" href=\"#" + uniqueHeaderId +
                "\" aria-controls=\"" + uniqueBodyId + "\">" + title + "</a></li>");

        stepItem._enableAria(options.enableAllSteps || state.currentIndex > index);

        if (state.currentIndex > index) {
            stepItem.addClass("done");
        }

        header._id(uniqueHeaderId).attr("tabindex", "-1").addClass("title");

        if (index === 0) {
            stepCollection.prepend(stepItem);
        }
        else {
            stepCollection.find("li").eq(index - 1).after(stepItem);
        }

        // Set the "first" class to the new first step button
        if (index === 0) {
            stepCollection.find("li").removeClass("first").eq(index).addClass("first");
        }

        // Set the "last" class to the new last step button
        if (index === (state.stepCount - 1)) {
            stepCollection.find("li").removeClass("last").eq(index).addClass("last");
        }

        // Register click event
        stepItem.children("a").bind("click" + getEventNamespace(wizard), stepClickHandler);
    }

    /**
     * Saves the current state to a cookie.
     *
     * @static
     * @private
     * @method saveCurrentStateToCookie
     * @param wizard {Object} A jQuery wizard object
     * @param options {Object} Settings of the current wizard
     * @param state {Object} The state container of the current wizard
     */
    function saveCurrentStateToCookie(wizard, options, state) {
        if (options.saveState && $.cookie) {
            $.cookie(_cookiePrefix + getUniqueId(wizard), state.currentIndex);
        }
    }

    function startTransitionEffect(wizard, options, state, index, oldIndex, doneCallback) {
        var stepContents = wizard.find(".content > .body"),
            effect = getValidEnumValue(transitionEffect, options.transitionEffect),
            effectSpeed = options.transitionEffectSpeed,
            newStep = stepContents.eq(index),
            currentStep = stepContents.eq(oldIndex);

        switch (effect) {
            case transitionEffect.fade:
            case transitionEffect.slide:
                var hide = (effect === transitionEffect.fade) ? "fadeOut" : "slideUp",
                    show = (effect === transitionEffect.fade) ? "fadeIn" : "slideDown";

                state.transitionElement = newStep;
                currentStep[hide](effectSpeed, function () {
                    var wizard = $(this)._showAria(false).parent().parent(),
                        state = getState(wizard);

                    if (state.transitionElement) {
                        state.transitionElement[show](effectSpeed, function () {
                            $(this)._showAria();
                        }).promise().done(doneCallback);
                        state.transitionElement = null;
                    }
                });
                break;

            case transitionEffect.slideLeft:
                var outerWidth = currentStep.outerWidth(true),
                    posFadeOut = (index > oldIndex) ? -(outerWidth) : outerWidth,
                    posFadeIn = (index > oldIndex) ? outerWidth : -(outerWidth);

                $.when(currentStep.animate({left: posFadeOut}, effectSpeed,
                    function () {
                        $(this)._showAria(false);
                    }),
                    newStep.css("left", posFadeIn + "px")._showAria()
                        .animate({left: 0}, effectSpeed)).done(doneCallback);
                break;

            default:
                $.when(currentStep._showAria(false), newStep._showAria())
                    .done(doneCallback);
                break;
        }
    }

    /**
     * Fires when a step click happens.
     *
     * @static
     * @private
     * @event click
     * @param event {Object} An event object
     */
    function stepClickHandler(event) {
        event.preventDefault();

        var anchor = $(this),
            wizard = anchor.parent().parent().parent().parent(),
            options = getOptions(wizard),
            state = getState(wizard),
            oldIndex = state.currentIndex;

        if (anchor.parent().is(":not(.disabled):not(.current)")) {
            var href = anchor.attr("href"),
                position = parseInt(href.substring(href.lastIndexOf("-") + 1), 0);

            goToStep(wizard, options, state, position);
        }

        // If nothing has changed
        if (oldIndex === state.currentIndex) {
            getStepAnchor(wizard, oldIndex).focus();
            return false;
        }
    }

    function throwError(message) {
        if (arguments.length > 1) {
            message = message.format(Array.prototype.slice.call(arguments, 1));
        }

        throw new Error(message);
    }

    /**
     * Checks an argument for null or undefined and throws an error if one check applies.
     *
     * @static
     * @private
     * @method validateArgument
     * @param argumentName {String} The name of the given argument
     * @param argumentValue {Object} The argument itself
     */
    function validateArgument(argumentName, argumentValue) {
        if (argumentValue == null) {
            throwError("The argument '{0}' is null or undefined.", argumentName);
        }
    }

    /**
     * Represents a jQuery wizard plugin.
     *
     * @class steps
     * @constructor
     * @param [method={}] The name of the method as `String` or an JSON object for initialization
     * @param [params=]* {Array} Additional arguments for a method call
     * @chainable
     **/
    $.fn.steps = function (method) {
        if ($.fn.steps[method]) {
            return $.fn.steps[method].apply(this, Array.prototype.slice.call(arguments, 1));
        }
        else if (typeof method === "object" || !method) {
            return initialize.apply(this, arguments);
        }
        else {
            $.error("Method " + method + " does not exist on jQuery.steps");
        }
    };

    /**
     * Adds a new step.
     *
     * @method add
     * @param step {Object} The step object to add
     * @chainable
     **/
    $.fn.steps.add = function (step) {
        var state = getState(this);
        return insertStep(this, getOptions(this), state, state.stepCount, step);
    };

    /**
     * Removes the control functionality completely and transforms the current state to the initial HTML structure.
     *
     * @method destroy
     * @chainable
     **/
    $.fn.steps.destroy = function () {
        return destroy(this, getOptions(this));
    };

    /**
     * Triggers the onFinishing and onFinished event.
     *
     * @method finish
     **/
    $.fn.steps.finish = function () {
        finishStep(this, getState(this));
    };

    /**
     * Gets the current step index.
     *
     * @method getCurrentIndex
     * @return {Integer} The actual step index (zero-based)
     * @for steps
     **/
    $.fn.steps.getCurrentIndex = function () {
        return getState(this).currentIndex;
    };

    /**
     * Gets the current step object.
     *
     * @method getCurrentStep
     * @return {Object} The actual step object
     **/
    $.fn.steps.getCurrentStep = function () {
        return getStep(this, getState(this).currentIndex);
    };

    /**
     * Gets a specific step object by index.
     *
     * @method getStep
     * @param index {Integer} An integer that belongs to the position of a step
     * @return {Object} A specific step object
     **/
    $.fn.steps.getStep = function (index) {
        return getStep(this, index);
    };

    /**
     * Inserts a new step to a specific position.
     *
     * @method insert
     * @param index {Integer} The position (zero-based) to add
     * @param step {Object} The step object to add
     * @example
     *     $("#wizard").steps().insert(0, {
 *         title: "Title",
 *         content: "", // optional
 *         contentMode: "async", // optional
 *         contentUrl: "/Content/Step/1" // optional
 *     });
     * @chainable
     **/
    $.fn.steps.insert = function (index, step) {
        return insertStep(this, getOptions(this), getState(this), index, step);
    };

    /**
     * Routes to the next step.
     *
     * @method next
     * @return {Boolean} Indicates whether the action executed
     **/
    $.fn.steps.next = function () {
        return goToNextStep(this, getOptions(this), getState(this));
    };

    /**
     * Routes to the previous step.
     *
     * @method previous
     * @return {Boolean} Indicates whether the action executed
     **/
    $.fn.steps.previous = function () {
        return goToPreviousStep(this, getOptions(this), getState(this));
    };

    /**
     * Removes a specific step by an given index.
     *
     * @method remove
     * @param index {Integer} The position (zero-based) of the step to remove
     * @return Indecates whether the item is removed.
     **/
    $.fn.steps.remove = function (index) {
        return removeStep(this, getOptions(this), getState(this), index);
    };

    /**
     * Sets a specific step object by index.
     *
     * @method setStep
     * @param index {Integer} An integer that belongs to the position of a step
     * @param step {Object} The step object to change
     **/
    $.fn.steps.setStep = function (index, step) {
        throw new Error("Not yet implemented!");
    };

    /**
     * Skips an certain amount of steps.
     *
     * @method skip
     * @param count {Integer} The amount of steps that should be skipped
     * @return {Boolean} Indicates whether the action executed
     **/
    $.fn.steps.skip = function (count) {
        throw new Error("Not yet implemented!");
    };

    /**
     * An enum represents the different content types of a step and their loading mechanisms.
     *
     * @class contentMode
     * @for steps
     **/
    var contentMode = $.fn.steps.contentMode = {
        /**
         * HTML embedded content
         *
         * @readOnly
         * @property html
         * @type Integer
         * @for contentMode
         **/
        html: 0,

        /**
         * IFrame embedded content
         *
         * @readOnly
         * @property iframe
         * @type Integer
         * @for contentMode
         **/
        iframe: 1,

        /**
         * Async embedded content
         *
         * @readOnly
         * @property async
         * @type Integer
         * @for contentMode
         **/
        async: 2
    };

    /**
     * An enum represents the orientation of the steps navigation.
     *
     * @class stepsOrientation
     * @for steps
     **/
    var stepsOrientation = $.fn.steps.stepsOrientation = {
        /**
         * Horizontal orientation
         *
         * @readOnly
         * @property horizontal
         * @type Integer
         * @for stepsOrientation
         **/
        horizontal: 0,

        /**
         * Vertical orientation
         *
         * @readOnly
         * @property vertical
         * @type Integer
         * @for stepsOrientation
         **/
        vertical: 1
    };

    /**
     * An enum that represents the various transition animations.
     *
     * @class transitionEffect
     * @for steps
     **/
    var transitionEffect = $.fn.steps.transitionEffect = {
        /**
         * No transition animation
         *
         * @readOnly
         * @property none
         * @type Integer
         * @for transitionEffect
         **/
        none: 0,

        /**
         * Fade in transition
         *
         * @readOnly
         * @property fade
         * @type Integer
         * @for transitionEffect
         **/
        fade: 1,

        /**
         * Slide up transition
         *
         * @readOnly
         * @property slide
         * @type Integer
         * @for transitionEffect
         **/
        slide: 2,

        /**
         * Slide left transition
         *
         * @readOnly
         * @property slideLeft
         * @type Integer
         * @for transitionEffect
         **/
        slideLeft: 3
    };

    var stepModel = $.fn.steps.stepModel = {
        title: "",
        content: "",
        contentUrl: "",
        contentMode: contentMode.html,
        contentLoaded: false
    };

    /**
     * An object that represents the default settings.
     * There are two possibities to override the sub-properties.
     * Either by doing it generally (global) or on initialization.
     *
     * @static
     * @class defaults
     * @for steps
     * @example
     *   // Global approach
     *   $.steps.defaults.headerTag = "h3";
     * @example
     *   // Initialization approach
     *   $("#wizard").steps({ headerTag: "h3" });
     **/
    var defaults = $.fn.steps.defaults = {
        /**
         * The header tag is used to find the step button text within the declared wizard area.
         *
         * @property headerTag
         * @type String
         * @default "h1"
         * @for defaults
         **/
        headerTag: "h1",

        /**
         * The body tag is used to find the step content within the declared wizard area.
         *
         * @property bodyTag
         * @type String
         * @default "div"
         * @for defaults
         **/
        bodyTag: "div",

        /**
         * The content container tag which will be used to wrap all step contents.
         *
         * @property contentContainerTag
         * @type String
         * @default "div"
         * @for defaults
         **/
        contentContainerTag: "div",

        /**
         * The action container tag which will be used to wrap the pagination navigation.
         *
         * @property actionContainerTag
         * @type String
         * @default "div"
         * @for defaults
         **/
        actionContainerTag: "div",

        /**
         * The steps container tag which will be used to wrap the steps navigation.
         *
         * @property stepsContainerTag
         * @type String
         * @default "div"
         * @for defaults
         **/
        stepsContainerTag: "div",

        /**
         * The css class which will be added to the outer component wrapper.
         *
         * @property cssClass
         * @type String
         * @default "wizard"
         * @for defaults
         * @example
         *     <div class="wizard">
         *         ...
         *     </div>
         **/
        cssClass: "wizard",

        /**
         * The css class which will be used for floating scenarios.
         *
         * @property clearFixCssClass
         * @type String
         * @default "clearfix"
         * @for defaults
         **/
        clearFixCssClass: "clearfix",

        /**
         * Determines whether the steps are vertically or horizontally oriented.
         *
         * @property stepsOrientation
         * @type stepsOrientation
         * @default horizontal
         * @for defaults
         * @since 1.0.0
         **/
        stepsOrientation: stepsOrientation.horizontal,

        /*
         * Tempplates
         */

        /**
         * The title template which will be used to create a step button.
         *
         * @property titleTemplate
         * @type String
         * @default "<span class=\"number\">#index#.</span> #title#"
         * @for defaults
         **/
        titleTemplate: "<span class=\"number\">#index#.</span> #title#",

        /**
         * The loading template which will be used to create the loading animation.
         *
         * @property loadingTemplate
         * @type String
         * @default "<span class=\"spinner\"></span> #text#"
         * @for defaults
         **/
        loadingTemplate: "<span class=\"spinner\"></span> #text#",

        /*
         * Behaviour
         */

        /**
         * Sets the focus to the first wizard instance in order to enable the key navigation from the begining if `true`.
         *
         * @property autoFocus
         * @type Boolean
         * @default false
         * @for defaults
         * @since 0.9.4
         **/
        autoFocus: false,

        /**
         * Enables all steps from the begining if `true` (all steps are clickable).
         *
         * @property enableAllSteps
         * @type Boolean
         * @default false
         * @for defaults
         **/
        enableAllSteps: false,

        /**
         * Enables keyboard navigation if `true` (arrow left and arrow right).
         *
         * @property enableKeyNavigation
         * @type Boolean
         * @default true
         * @for defaults
         **/
        enableKeyNavigation: true,

        /**
         * Enables pagination if `true`.
         *
         * @property enablePagination
         * @type Boolean
         * @default true
         * @for defaults
         **/
        enablePagination: true,

        /**
         * Suppresses pagination if a form field is focused.
         *
         * @property suppressPaginationOnFocus
         * @type Boolean
         * @default true
         * @for defaults
         **/
        suppressPaginationOnFocus: true,

        /**
         * Enables cache for async loaded or iframe embedded content.
         *
         * @property enableContentCache
         * @type Boolean
         * @default true
         * @for defaults
         **/
        enableContentCache: true,

        /**
         * Shows the cancel button if enabled.
         *
         * @property enableCancelButton
         * @type Boolean
         * @default false
         * @for defaults
         **/
        enableCancelButton: false,

        /**
         * Shows the finish button if enabled.
         *
         * @property enableFinishButton
         * @type Boolean
         * @default true
         * @for defaults
         **/
        enableFinishButton: true,

        /**
         * Not yet implemented.
         *
         * @property preloadContent
         * @type Boolean
         * @default false
         * @for defaults
         **/
        preloadContent: false,

        /**
         * Shows the finish button always (on each step; right beside the next button) if `true`.
         * Otherwise the next button will be replaced by the finish button if the last step becomes active.
         *
         * @property showFinishButtonAlways
         * @type Boolean
         * @default false
         * @for defaults
         **/
        showFinishButtonAlways: false,

        /**
         * Prevents jumping to a previous step.
         *
         * @property forceMoveForward
         * @type Boolean
         * @default false
         * @for defaults
         **/
        forceMoveForward: false,

        /**
         * Saves the current state (step position) to a cookie.
         * By coming next time the last active step becomes activated.
         *
         * @property saveState
         * @type Boolean
         * @default false
         * @for defaults
         **/
        saveState: false,

        /**
         * The position to start on (zero-based).
         *
         * @property startIndex
         * @type Integer
         * @default 0
         * @for defaults
         **/
        startIndex: 0,

        /*
         * Animation Effect Configuration
         */

        /**
         * The animation effect which will be used for step transitions.
         *
         * @property transitionEffect
         * @type transitionEffect
         * @default none
         * @for defaults
         **/
        transitionEffect: transitionEffect.none,

        /**
         * Animation speed for step transitions (in milliseconds).
         *
         * @property transitionEffectSpeed
         * @type Integer
         * @default 200
         * @for defaults
         **/
        transitionEffectSpeed: 200,

        /*
         * Events
         */

        /**
         * Fires before the step changes and can be used to prevent step changing by returning `false`.
         * Very useful for form validation.
         *
         * @property onStepChanging
         * @type Event
         * @default function (event, currentIndex, newIndex) { return true; }
         * @for defaults
         **/
        onStepChanging: function (event, currentIndex, newIndex) {
            return true;
        },

        /**
         * Fires after the step has change.
         *
         * @property onStepChanged
         * @type Event
         * @default function (event, currentIndex, priorIndex) { }
         * @for defaults
         **/
        onStepChanged: function (event, currentIndex, priorIndex) {
        },

        /**
         * Fires after cancelation.
         *
         * @property onCanceled
         * @type Event
         * @default function (event) { }
         * @for defaults
         **/
        onCanceled: function (event) {
        },

        /**
         * Fires before finishing and can be used to prevent completion by returning `false`.
         * Very useful for form validation.
         *
         * @property onFinishing
         * @type Event
         * @default function (event, currentIndex) { return true; }
         * @for defaults
         **/
        onFinishing: function (event, currentIndex) {
            return true;
        },

        /**
         * Fires after completion.
         *
         * @property onFinished
         * @type Event
         * @default function (event, currentIndex) { }
         * @for defaults
         **/
        onFinished: function (event, currentIndex) {
        },

        /**
         * Fires after async content is loaded.
         *
         * @property onContentLoaded
         * @type Event
         * @default function (event, index) { }
         * @for defaults
         **/
        onContentLoaded: function (event, currentIndex) {
        },

        /**
         * Fires when the wizard is initialized.
         *
         * @property onInit
         * @type Event
         * @default function (event) { }
         * @for defaults
         **/
        onInit: function (event, currentIndex) {
        },

        /**
         * Contains all labels.
         *
         * @property labels
         * @type Object
         * @for defaults
         **/
        labels: {
            /**
             * Label for the cancel button.
             *
             * @property cancel
             * @type String
             * @default "Cancel"
             * @for defaults
             **/
            cancel: "Cancel",

            /**
             * This label is important for accessability reasons.
             * Indicates which step is activated.
             *
             * @property current
             * @type String
             * @default "current step:"
             * @for defaults
             **/
            current: "current step:",

            /**
             * This label is important for accessability reasons and describes the kind of navigation.
             *
             * @property pagination
             * @type String
             * @default "Pagination"
             * @for defaults
             * @since 0.9.7
             **/
            pagination: "Pagination",

            /**
             * Label for the finish button.
             *
             * @property finish
             * @type String
             * @default "Finish"
             * @for defaults
             **/
            finish: "Finish",

            /**
             * Label for the next button.
             *
             * @property next
             * @type String
             * @default "Next"
             * @for defaults
             **/
            next: "Next",

            /**
             * Label for the previous button.
             *
             * @property previous
             * @type String
             * @default "Previous"
             * @for defaults
             **/
            previous: "Previous",

            /**
             * Label for the loading animation.
             *
             * @property loading
             * @type String
             * @default "Loading ..."
             * @for defaults
             **/
            loading: "Loading ..."
        }
    };
})(jQuery);